home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / MOR55SRC.ZIP / MORIA / SOURCE / MISC2.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-07  |  26.1 KB  |  1,093 lines
  1. /* source/misc2.c: misc utility and initialization code, magic objects code
  2.  
  3.    Copyright (c) 1989-92 James E. Wilson, Robert A. Koeneke
  4.  
  5.    This software may be copied and distributed for educational, research, and
  6.    not for profit purposes provided that this copyright and statement are
  7.    included in all such copies. */
  8.  
  9. #ifdef __TURBOC__
  10. #include    <stdio.h>
  11. #endif /* __TURBOC__ */
  12.  
  13. #include "config.h"
  14. #include "constant.h"
  15. #include "types.h"
  16. #include "externs.h"
  17.  
  18.  
  19. /* Chance of treasure having magic abilities        -RAK-    */
  20. /* Chance increases with each dungeon level             */
  21. void magic_treasure(x, level)
  22. int x, level;
  23. {
  24.   register inven_type *t_ptr;
  25.   register int chance, special, cursed, i;
  26.   int tmp;
  27. #ifdef ATARIST_MWC
  28.   int32u holder;
  29. #endif
  30.  
  31.   chance = OBJ_BASE_MAGIC + level;
  32.   if (chance > OBJ_BASE_MAX)
  33.     chance = OBJ_BASE_MAX;
  34.   special = chance / OBJ_DIV_SPECIAL;
  35.   cursed  = (10 * chance) / OBJ_DIV_CURSED;
  36.   t_ptr = &t_list[x];
  37.  
  38.   /* some objects appear multiple times in the object_list with different
  39.      levels, this is to make the object occur more often, however, for
  40.      consistency, must set the level of these duplicates to be the same
  41.      as the object with the lowest level */
  42.  
  43.   /* Depending on treasure type, it can have certain magical properties*/
  44.   switch (t_ptr->tval)
  45.     {
  46.     case TV_SHIELD: case TV_HARD_ARMOR: case TV_SOFT_ARMOR:
  47.       if (magik(chance))
  48.     {
  49.       t_ptr->toac += m_bonus(1, 30, level);
  50.       if (magik(special))
  51.         switch(randint(9))
  52.           {
  53.           case 1:
  54. #ifdef ATARIST_MWC
  55.         t_ptr->flags |= (holder = TR_RES_LIGHT|TR_RES_COLD|TR_RES_ACID|
  56.                  TR_RES_FIRE);
  57. #else
  58.         t_ptr->flags |= (TR_RES_LIGHT|TR_RES_COLD|TR_RES_ACID|
  59.                  TR_RES_FIRE);
  60. #endif
  61.         t_ptr->name2 = SN_R;
  62.         t_ptr->toac += 5;
  63.         t_ptr->cost += 2500;
  64.         break;
  65.           case 2:     /* Resist Acid      */
  66. #ifdef ATARIST_MWC
  67.         t_ptr->flags |= (holder = TR_RES_ACID);
  68. #else
  69.         t_ptr->flags |= TR_RES_ACID;
  70. #endif
  71.         t_ptr->name2 = SN_RA;
  72.         t_ptr->cost += 1000;
  73.         break;
  74.           case 3: case 4:     /* Resist Fire      */
  75. #ifdef ATARIST_MWC
  76.         t_ptr->flags |= (holder = TR_RES_FIRE);
  77. #else
  78.         t_ptr->flags |= TR_RES_FIRE;
  79. #endif
  80.         t_ptr->name2 = SN_RF;
  81.         t_ptr->cost += 600;
  82.         break;
  83.           case 5: case 6:    /* Resist Cold     */
  84. #ifdef ATARIST_MWC
  85.         t_ptr->flags |= (holder = TR_RES_COLD);
  86. #else
  87.         t_ptr->flags |= TR_RES_COLD;
  88. #endif
  89.         t_ptr->name2 = SN_RC;
  90.         t_ptr->cost += 600;
  91.         break;
  92.           case 7: case 8: case 9:  /* Resist Lightning*/
  93. #ifdef ATARIST_MWC
  94.         t_ptr->flags |= (holder = TR_RES_LIGHT);
  95. #else
  96.         t_ptr->flags |= TR_RES_LIGHT;
  97. #endif
  98.         t_ptr->name2 = SN_RL;
  99.         t_ptr->cost += 500;
  100.         break;
  101.           }
  102.     }
  103.       else if (magik(cursed))
  104.     {
  105.       t_ptr->toac -= m_bonus(1, 40, level);
  106.       t_ptr->cost = 0;
  107. #ifdef ATARIST_MWC
  108.       t_ptr->flags |= (holder = TR_CURSED);
  109. #else
  110.       t_ptr->flags |= TR_CURSED;
  111. #endif
  112.     }
  113.       break;
  114.  
  115.     case TV_HAFTED: case TV_POLEARM: case TV_SWORD:
  116.       /* always show tohit/todam values if identified */
  117.       t_ptr->ident |= ID_SHOW_HITDAM;
  118.       if (magik(chance))
  119.     {
  120.       t_ptr->tohit += m_bonus(0, 40, level);
  121.       /* Magical damage bonus now proportional to weapon base damage */
  122.       tmp = t_ptr->damage[0] * t_ptr->damage[1];
  123.       t_ptr->todam += m_bonus(0, 4*tmp, tmp*level/10);
  124.       /* the 3*special/2 is needed because weapons are not as common as
  125.          before change to treasure distribution, this helps keep same
  126.          number of ego weapons same as before, see also missiles */
  127.       if (magik(3*special/2))
  128.         switch(randint(16))
  129.           {
  130.           case 1:    /* Holy Avenger     */
  131. #ifdef ATARIST_MWC
  132.         t_ptr->flags |= (holder = TR_SEE_INVIS|TR_SUST_STAT|
  133.                  TR_SLAY_UNDEAD|TR_SLAY_EVIL|TR_STR);
  134. #else
  135.         t_ptr->flags |= (TR_SEE_INVIS|TR_SUST_STAT|TR_SLAY_UNDEAD|
  136.                  TR_SLAY_EVIL|TR_STR);
  137. #endif
  138.         t_ptr->tohit += 5;
  139.         t_ptr->todam += 5;
  140.         t_ptr->toac  += randint(4);
  141.         /* the value in p1 is used for strength increase */
  142.         /* p1 is also used for sustain stat */
  143.         t_ptr->p1    = randint(4);
  144.         t_ptr->name2 = SN_HA;
  145.         t_ptr->cost += t_ptr->p1*500;
  146.         t_ptr->cost += 10000;
  147.         break;
  148.           case 2:    /* Defender     */
  149. #ifdef ATARIST_MWC
  150.         t_ptr->flags |= (holder = TR_FFALL|TR_RES_LIGHT|TR_SEE_INVIS|
  151.                  TR_FREE_ACT|TR_RES_COLD|TR_RES_ACID|
  152.                  TR_RES_FIRE|TR_REGEN|TR_STEALTH);
  153. #else
  154.         t_ptr->flags |= (TR_FFALL|TR_RES_LIGHT|TR_SEE_INVIS|TR_FREE_ACT
  155.                  |TR_RES_COLD|TR_RES_ACID|TR_RES_FIRE|
  156.                  TR_REGEN|TR_STEALTH);
  157. #endif
  158.         t_ptr->tohit += 3;
  159.         t_ptr->todam += 3;
  160.         t_ptr->toac  += 5 + randint(5);
  161.         t_ptr->name2 = SN_DF;
  162.         /* the value in p1 is used for stealth */
  163.         t_ptr->p1    = randint(3);
  164.         t_ptr->cost += t_ptr->p1*500;
  165.         t_ptr->cost += 7500;
  166.         break;
  167.           case 3: case 4:     /* Slay Animal  */
  168.         t_ptr->flags |= TR_SLAY_ANIMAL;
  169.         t_ptr->tohit += 3;
  170.         t_ptr->todam += 3;
  171.         t_ptr->name2 = SN_SA;
  172.         t_ptr->cost += 5000;
  173.         break;
  174.           case 5: case 6:    /* Slay Dragon     */
  175.         t_ptr->flags |= TR_SLAY_DRAGON;
  176.         t_ptr->tohit += 3;
  177.         t_ptr->todam += 3;
  178.         t_ptr->name2 = SN_SD;
  179.         t_ptr->cost += 4000;
  180.         break;
  181.           case 7: case 8:      /* Slay Evil       */
  182.         t_ptr->flags |= TR_SLAY_EVIL;
  183.         t_ptr->tohit += 3;
  184.         t_ptr->todam += 3;
  185.         t_ptr->name2 = SN_SE;
  186.         t_ptr->cost += 4000;
  187.         break;
  188.           case 9: case 10:     /* Slay Undead      */
  189. #ifdef ATARIST_MWC
  190.         t_ptr->flags |= (holder = TR_SEE_INVIS|TR_SLAY_UNDEAD);
  191. #else
  192.         t_ptr->flags |= (TR_SEE_INVIS|TR_SLAY_UNDEAD);
  193. #endif
  194.         t_ptr->tohit += 2;
  195.         t_ptr->todam += 2;
  196.         t_ptr->name2 = SN_SU;
  197.         t_ptr->cost += 3000;
  198.         break;
  199.           case 11: case 12: case 13:   /* Flame Tongue  */
  200. #ifdef ATARIST_MWC
  201.         t_ptr->flags |= (holder = TR_FLAME_TONGUE);
  202. #else
  203.         t_ptr->flags |= TR_FLAME_TONGUE;
  204. #endif
  205.         t_ptr->tohit++;
  206.         t_ptr->todam += 3;
  207.         t_ptr->name2 = SN_FT;
  208.         t_ptr->cost += 2000;
  209.         break;
  210.           case 14: case 15: case 16:   /* Frost Brand   */
  211. #ifdef ATARIST_MWC
  212.         t_ptr->flags |= (holder = TR_FROST_BRAND);
  213. #else
  214.         t_ptr->flags |= TR_FROST_BRAND;
  215. #endif
  216.         t_ptr->tohit++;
  217.         t_ptr->todam++;
  218.         t_ptr->name2 = SN_FB;
  219.         t_ptr->cost += 1200;
  220.         break;
  221.           }
  222.     }
  223.       else if (magik(cursed))
  224.     {
  225.       t_ptr->tohit -= m_bonus(1, 55, level);
  226.       /* Magical damage bonus now proportional to weapon base damage */
  227.       tmp = t_ptr->damage[0] * t_ptr->damage[1];
  228.       t_ptr->todam -= m_bonus(1, 11*tmp/2, tmp*level/10);
  229. #ifdef ATARIST_MWC
  230.       t_ptr->flags |= (holder = TR_CURSED);
  231. #else
  232.       t_ptr->flags |= TR_CURSED;
  233. #endif
  234.       t_ptr->cost = 0;
  235.     }
  236.       break;
  237.  
  238.     case TV_BOW:
  239.       /* always show tohit/todam values if identified */
  240.       t_ptr->ident |= ID_SHOW_HITDAM;
  241.       if (magik(chance))
  242.     {
  243.       t_ptr->tohit += m_bonus(1, 30, level);
  244.       t_ptr->todam += m_bonus(1, 20, level); /* add damage. -CJS- */
  245.     }
  246.       else if (magik(cursed))
  247.     {
  248.       t_ptr->tohit -= m_bonus(1, 50, level);
  249.       t_ptr->todam -= m_bonus(1, 30, level); /* add damage. -CJS- */
  250. #ifdef ATARIST_MWC
  251.       t_ptr->flags |= (holder = TR_CURSED);
  252. #else
  253.       t_ptr->flags |= TR_CURSED;
  254. #endif
  255.       t_ptr->cost = 0;
  256.     }
  257.       break;
  258.  
  259.     case TV_DIGGING:
  260.       /* always show tohit/todam values if identified */
  261.       t_ptr->ident |= ID_SHOW_HITDAM;
  262.       if (magik(chance))
  263.     {
  264.       tmp = randint(3);
  265.       if (tmp < 3)
  266.         t_ptr->p1 += m_bonus(0, 25, level);
  267.       else
  268.         {
  269.           /* a cursed digging tool */
  270.           t_ptr->p1 = -m_bonus(1, 30, level);
  271.           t_ptr->cost = 0;
  272. #ifdef ATARIST_MWC
  273.           t_ptr->flags |= (holder = TR_CURSED);
  274. #else
  275.           t_ptr->flags |= TR_CURSED;
  276. #endif
  277.         }
  278.     }
  279.       break;
  280.  
  281.     case TV_GLOVES:
  282.       if (magik(chance))
  283.     {
  284.       t_ptr->toac += m_bonus(1, 20, level);
  285.       if (magik(special))
  286.         {
  287.           if (randint(2) == 1)
  288.         {
  289. #ifdef ATARIST_MWC
  290.           t_ptr->flags |= (holder = TR_FREE_ACT);
  291. #else
  292.           t_ptr->flags |= TR_FREE_ACT;
  293. #endif
  294.           t_ptr->name2 = SN_FREE_ACTION;
  295.           t_ptr->cost += 1000;
  296.         }
  297.           else
  298.         {
  299.           t_ptr->ident |= ID_SHOW_HITDAM;
  300.           t_ptr->tohit += 1 + randint(3);
  301.           t_ptr->todam += 1 + randint(3);
  302.           t_ptr->name2 = SN_SLAYING;
  303.           t_ptr->cost += (t_ptr->tohit+t_ptr->todam)*250;
  304.         }
  305.         }
  306.     }
  307.       else if (magik(cursed))
  308.     {
  309.       if (magik(special))
  310.         {
  311.           if (randint(2) == 1)
  312.         {
  313.           t_ptr->flags |= TR_DEX;
  314.           t_ptr->name2 = SN_CLUMSINESS;
  315.         }
  316.           else
  317.         {
  318.           t_ptr->flags |= TR_STR;
  319.           t_ptr->name2 = SN_WEAKNESS;
  320.         }
  321.           t_ptr->ident |= ID_SHOW_P1;
  322.           t_ptr->p1   = -m_bonus(1, 10, level);
  323.         }
  324.       t_ptr->toac -= m_bonus(1, 40, level);
  325. #ifdef ATARIST_MWC
  326.       t_ptr->flags |= (holder = TR_CURSED);
  327. #else
  328.       t_ptr->flags |= TR_CURSED;
  329. #endif
  330.       t_ptr->cost = 0;
  331.     }
  332.       break;
  333.  
  334.     case TV_BOOTS:
  335.       if (magik(chance))
  336.     {
  337.       t_ptr->toac += m_bonus(1, 20, level);
  338.       if (magik(special))
  339.         {
  340.           tmp = randint(12);
  341.           if (tmp > 5)
  342.         {
  343. #ifdef ATARIST_MWC
  344.           t_ptr->flags |= (holder = TR_FFALL);
  345. #else
  346.           t_ptr->flags |= TR_FFALL;
  347. #endif
  348.           t_ptr->name2 = SN_SLOW_DESCENT;
  349.           t_ptr->cost += 250;
  350.         }
  351.           else if (tmp == 1)
  352.         {
  353.           t_ptr->flags |= TR_SPEED;
  354.           t_ptr->name2 = SN_SPEED;
  355.           t_ptr->ident |= ID_SHOW_P1;
  356.           t_ptr->p1 = 1;
  357.           t_ptr->cost += 5000;
  358.         }
  359.           else /* 2 - 5 */
  360.         {
  361.           t_ptr->flags |= TR_STEALTH;
  362.           t_ptr->ident |= ID_SHOW_P1;
  363.           t_ptr->p1 = randint(3);
  364.           t_ptr->name2 = SN_STEALTH;
  365.           t_ptr->cost += 500;
  366.         }
  367.         }
  368.     }
  369.       else if (magik(cursed))
  370.     {
  371.       tmp = randint(3);
  372.       if (tmp == 1)
  373.         {
  374.           t_ptr->flags |= TR_SPEED;
  375.           t_ptr->name2 = SN_SLOWNESS;
  376.           t_ptr->ident |= ID_SHOW_P1;
  377.           t_ptr->p1 = -1;
  378.         }
  379.       else if (tmp == 2)
  380.         {
  381.           t_ptr->flags |= TR_AGGRAVATE;
  382.           t_ptr->name2 = SN_NOISE;
  383.         }
  384.       else
  385.         {
  386.           t_ptr->name2 = SN_GREAT_MASS;
  387.           t_ptr->weight = t_ptr->weight * 5;
  388.         }
  389.       t_ptr->cost = 0;
  390.       t_ptr->toac -= m_bonus(2, 45, level);
  391. #ifdef ATARIST_MWC
  392.       t_ptr->flags |= (holder = TR_CURSED);
  393. #else
  394.       t_ptr->flags |= TR_CURSED;
  395. #endif
  396.     }
  397.       break;
  398.  
  399.     case TV_HELM:  /* Helms */
  400.       if ((t_ptr->subval >= 6) && (t_ptr->subval <= 8))
  401.     {
  402.       /* give crowns a higher chance for magic */
  403.       chance += (int) (t_ptr->cost / 100);
  404.       special += special;
  405.     }
  406.       if (magik(chance))
  407.     {
  408.       t_ptr->toac += m_bonus(1, 20, level);
  409.       if (magik(special))
  410.         {
  411.           if (t_ptr->subval < 6)
  412.         {
  413.           tmp = randint(3);
  414.           t_ptr->ident |= ID_SHOW_P1;
  415.           if (tmp == 1)
  416.             {
  417.               t_ptr->p1 = randint(2);
  418.               t_ptr->flags |= TR_INT;
  419.               t_ptr->name2 = SN_INTELLIGENCE;
  420.               t_ptr->cost += t_ptr->p1*500;
  421.             }
  422.           else if (tmp == 2)
  423.             {
  424.               t_ptr->p1 = randint(2);
  425.               t_ptr->flags |= TR_WIS;
  426.               t_ptr->name2 = SN_WISDOM;
  427.               t_ptr->cost += t_ptr->p1*500;
  428.             }
  429.           else
  430.             {
  431.               t_ptr->p1 = 1 + randint(4);
  432. #ifdef ATARIST_MWC
  433.               t_ptr->flags |= (holder = TR_INFRA);
  434. #else
  435.               t_ptr->flags |= TR_INFRA;
  436. #endif
  437.               t_ptr->name2 = SN_INFRAVISION;
  438.               t_ptr->cost += t_ptr->p1*250;
  439.             }
  440.         }
  441.           else
  442.         {
  443.           switch(randint(6))
  444.             {
  445.             case 1:
  446.               t_ptr->ident |= ID_SHOW_P1;
  447.               t_ptr->p1 = randint(3);
  448. #ifdef ATARIST_MWC
  449.               t_ptr->flags |= (holder = TR_FREE_ACT|TR_CON|TR_DEX|
  450.                        TR_STR);
  451. #else
  452.               t_ptr->flags |= (TR_FREE_ACT|TR_CON|TR_DEX|TR_STR);
  453. #endif
  454.               t_ptr->name2 = SN_MIGHT;
  455.               t_ptr->cost += 1000 + t_ptr->p1*500;
  456.               break;
  457.             case 2:
  458.               t_ptr->ident |= ID_SHOW_P1;
  459.               t_ptr->p1 = randint(3);
  460.               t_ptr->flags |= (TR_CHR|TR_WIS);
  461.               t_ptr->name2 = SN_LORDLINESS;
  462.               t_ptr->cost += 1000 + t_ptr->p1*500;
  463.               break;
  464.             case 3:
  465.               t_ptr->ident |= ID_SHOW_P1;
  466.               t_ptr->p1 = randint(3);
  467. #ifdef ATARIST_MWC
  468.               t_ptr->flags |= (holder = TR_RES_LIGHT|TR_RES_COLD|
  469.                        TR_RES_ACID|TR_RES_FIRE|TR_INT);
  470. #else
  471.               t_ptr->flags |= (TR_RES_LIGHT|TR_RES_COLD|TR_RES_ACID|
  472.                        TR_RES_FIRE|TR_INT);
  473. #endif
  474.               t_ptr->name2 = SN_MAGI;
  475.               t_ptr->cost += 3000 + t_ptr->p1*500;
  476.               break;
  477.             case 4:
  478.               t_ptr->ident |= ID_SHOW_P1;
  479.               t_ptr->p1 = randint(3);
  480.               t_ptr->flags |= TR_CHR;
  481.               t_ptr->name2 = SN_BEAUTY;
  482.               t_ptr->cost += 750;
  483.               break;
  484.             case 5:
  485.               t_ptr->ident |= ID_SHOW_P1;
  486.               t_ptr->p1 = 5*(1 + randint(4));
  487. #ifdef ATARIST_MWC
  488.               t_ptr->flags |= (holder = TR_SEE_INVIS|TR_SEARCH);
  489. #else
  490.               t_ptr->flags |= (TR_SEE_INVIS|TR_SEARCH);
  491. #endif
  492.               t_ptr->name2 = SN_SEEING;
  493.               t_ptr->cost += 1000 + t_ptr->p1*100;
  494.               break;
  495.             case 6:
  496.               t_ptr->flags |= TR_REGEN;
  497.               t_ptr->name2 = SN_REGENERATION;
  498.               t_ptr->cost += 1500;
  499.               break;
  500.             }
  501.         }
  502.         }
  503.     }
  504.       else if (magik(cursed))
  505.     {
  506.       t_ptr->toac -= m_bonus(1, 45, level);
  507. #ifdef ATARIST_MWC
  508.       t_ptr->flags |= (holder = TR_CURSED);
  509. #else
  510.       t_ptr->flags |= TR_CURSED;
  511. #endif
  512.       t_ptr->cost = 0;
  513.       if (magik(special))
  514.         switch(randint(7))
  515.           {
  516.           case 1:
  517.         t_ptr->ident |= ID_SHOW_P1;
  518.         t_ptr->p1 = -randint (5);
  519.         t_ptr->flags |= TR_INT;
  520.         t_ptr->name2 = SN_STUPIDITY;
  521.         break;
  522.           case 2:
  523.         t_ptr->ident |= ID_SHOW_P1;
  524.         t_ptr->p1 = -randint (5);
  525.         t_ptr->flags |= TR_WIS;
  526.         t_ptr->name2 = SN_DULLNESS;
  527.         break;
  528.           case 3:
  529. #ifdef ATARIST_MWC
  530.         t_ptr->flags |= (holder = TR_BLIND);
  531. #else
  532.         t_ptr->flags |= TR_BLIND;
  533. #endif
  534.         t_ptr->name2 = SN_BLINDNESS;
  535.         break;
  536.           case 4:
  537. #ifdef ATARIST_MWC
  538.         t_ptr->flags |= (holder = TR_TIMID);
  539. #else
  540.         t_ptr->flags |= TR_TIMID;
  541. #endif
  542.         t_ptr->name2 = SN_TIMIDNESS;
  543.         break;
  544.           case 5:
  545.         t_ptr->ident |= ID_SHOW_P1;
  546.         t_ptr->p1 = -randint (5);
  547.         t_ptr->flags |= TR_STR;
  548.         t_ptr->name2 = SN_WEAKNESS;
  549.         break;
  550.           case 6:
  551.         t_ptr->flags |= TR_TELEPORT;
  552.         t_ptr->name2 = SN_TELEPORTATION;
  553.         break;
  554.           case 7:
  555.         t_ptr->ident |= ID_SHOW_P1;
  556.         t_ptr->p1 = -randint (5);
  557.         t_ptr->flags |= TR_CHR;
  558.         t_ptr->name2 = SN_UGLINESS;
  559.         break;
  560.           }
  561.     }
  562.       break;
  563.  
  564.     case TV_RING: /* Rings          */
  565.       switch(t_ptr->subval)
  566.     {
  567.     case 0: case 1: case 2: case 3:
  568.       if (magik(cursed))
  569.         {
  570.           t_ptr->p1 = -m_bonus(1, 20, level);
  571. #ifdef ATARIST_MWC
  572.           t_ptr->flags |= TR_CURSED;
  573. #else
  574.           t_ptr->flags |= TR_CURSED;
  575. #endif
  576.           t_ptr->cost = -t_ptr->cost;
  577.         }
  578.       else
  579.         {
  580.           t_ptr->p1 = m_bonus(1, 10, level);
  581.           t_ptr->cost += t_ptr->p1*100;
  582.         }
  583.       break;
  584.     case 4:
  585.       if (magik(cursed))
  586.         {
  587.           t_ptr->p1 = -randint(3);
  588. #ifdef ATARIST_MWC
  589.           t_ptr->flags |= (holder = TR_CURSED);
  590. #else
  591.           t_ptr->flags |= TR_CURSED;
  592. #endif
  593.           t_ptr->cost = -t_ptr->cost;
  594.         }
  595.       else
  596.         t_ptr->p1 = 1;
  597.       break;
  598.     case 5:
  599.       t_ptr->p1 = 5 * m_bonus(1, 20, level);
  600.       t_ptr->cost += t_ptr->p1*50;
  601.       if (magik (cursed))
  602.         {
  603.           t_ptr->p1 = -t_ptr->p1;
  604. #ifdef ATARIST_MWC
  605.           t_ptr->flags |= (holder = TR_CURSED);
  606. #else
  607.           t_ptr->flags |= TR_CURSED;
  608. #endif
  609.           t_ptr->cost = -t_ptr->cost;
  610.         }
  611.       break;
  612.     case 19:     /* Increase damage          */
  613.       t_ptr->todam += m_bonus(1, 20, level);
  614.       t_ptr->cost += t_ptr->todam*100;
  615.       if (magik(cursed))
  616.         {
  617.           t_ptr->todam = -t_ptr->todam;
  618. #ifdef ATARIST_MWC
  619.           t_ptr->flags |= (holder = TR_CURSED);
  620. #else
  621.           t_ptr->flags |= TR_CURSED;
  622. #endif
  623.           t_ptr->cost = -t_ptr->cost;
  624.         }
  625.       break;
  626.     case 20:     /* Increase To-Hit          */
  627.       t_ptr->tohit += m_bonus(1, 20, level);
  628.       t_ptr->cost += t_ptr->tohit*100;
  629.       if (magik(cursed))
  630.         {
  631.           t_ptr->tohit = -t_ptr->tohit;
  632. #ifdef ATARIST_MWC
  633.           t_ptr->flags |= (holder = TR_CURSED);
  634. #else
  635.           t_ptr->flags |= TR_CURSED;
  636. #endif
  637.           t_ptr->cost = -t_ptr->cost;
  638.         }
  639.       break;
  640.     case 21:     /* Protection          */
  641.       t_ptr->toac += m_bonus(1, 20, level);
  642.       t_ptr->cost += t_ptr->toac*100;
  643.       if (magik(cursed))
  644.         {
  645.           t_ptr->toac = -t_ptr->toac;
  646. #ifdef ATARIST_MWC
  647.           t_ptr->flags |= (holder = TR_CURSED);
  648. #else
  649.           t_ptr->flags |= TR_CURSED;
  650. #endif
  651.           t_ptr->cost = -t_ptr->cost;
  652.         }
  653.       break;
  654.     case 24: case 25: case 26:
  655.     case 27: case 28: case 29:
  656.       t_ptr->ident |= ID_NOSHOW_P1;
  657.       break;
  658.     case 30:     /* Slaying          */
  659.       t_ptr->ident |= ID_SHOW_HITDAM;
  660.       t_ptr->todam += m_bonus(1, 25, level);
  661.       t_ptr->tohit += m_bonus(1, 25, level);
  662.       t_ptr->cost += (t_ptr->tohit+t_ptr->todam)*100;
  663.       if (magik(cursed))
  664.         {
  665.           t_ptr->tohit = -t_ptr->tohit;
  666.           t_ptr->todam = -t_ptr->todam;
  667. #ifdef ATARIST_MWC
  668.           t_ptr->flags |= (holder = TR_CURSED);
  669. #else
  670.           t_ptr->flags |= TR_CURSED;
  671. #endif
  672.           t_ptr->cost = -t_ptr->cost;
  673.         }
  674.       break;
  675.     default:
  676.       break;
  677.     }
  678.       break;
  679.  
  680.     case TV_AMULET: /* Amulets          */
  681.       if (t_ptr->subval < 2)
  682.     {
  683.       if (magik(cursed))
  684.         {
  685.           t_ptr->p1 = -m_bonus(1, 20, level);
  686. #ifdef ATARIST_MWC
  687.           t_ptr->flags |= (holder = TR_CURSED);
  688. #else
  689.           t_ptr->flags |= TR_CURSED;
  690. #endif
  691.           t_ptr->cost = -t_ptr->cost;
  692.         }
  693.       else
  694.         {
  695.           t_ptr->p1 = m_bonus(1, 10, level);
  696.           t_ptr->cost += t_ptr->p1*100;
  697.         }
  698.     }
  699.       else if (t_ptr->subval == 2)
  700.     {
  701.       t_ptr->p1 = 5 * m_bonus(1, 25, level);
  702.       if (magik(cursed))
  703.         {
  704.           t_ptr->p1 = -t_ptr->p1;
  705.           t_ptr->cost = -t_ptr->cost;
  706. #ifdef ATARIST_MWC
  707.           t_ptr->flags |= (holder = TR_CURSED);
  708. #else
  709.           t_ptr->flags |= TR_CURSED;
  710. #endif
  711.         }
  712.       else
  713.         t_ptr->cost += 50*t_ptr->p1;
  714.     }
  715.       else if (t_ptr->subval == 8)
  716.     {
  717.       /* amulet of the magi is never cursed */
  718.       t_ptr->p1 = 5 * m_bonus(1, 25, level);
  719.       t_ptr->cost += 20*t_ptr->p1;
  720.     }
  721.       break;
  722.  
  723.       /* Subval should be even for store, odd for dungeon*/
  724.       /* Dungeon found ones will be partially charged     */
  725.     case TV_LIGHT:
  726.       if ((t_ptr->subval % 2) == 1)
  727.     {
  728.       t_ptr->p1 = randint(t_ptr->p1);
  729.       t_ptr->subval -= 1;
  730.     }
  731.       break;
  732.  
  733.     case TV_WAND:
  734.       switch(t_ptr->subval)
  735.     {
  736.     case 0:      t_ptr->p1 = randint(10) +     6; break;
  737.     case 1:      t_ptr->p1 = randint(8)  +     6; break;
  738.     case 2:      t_ptr->p1 = randint(5)  +     6; break;
  739.     case 3:      t_ptr->p1 = randint(8)  +     6; break;
  740.     case 4:      t_ptr->p1 = randint(4)  +     3; break;
  741.     case 5:      t_ptr->p1 = randint(8)  +     6; break;
  742.     case 6:      t_ptr->p1 = randint(20) +     12; break;
  743.     case 7:      t_ptr->p1 = randint(20) +     12; break;
  744.     case 8:      t_ptr->p1 = randint(10) +     6; break;
  745.     case 9:      t_ptr->p1 = randint(12) +     6; break;
  746.     case 10:   t_ptr->p1 = randint(10) +     12; break;
  747.     case 11:   t_ptr->p1 = randint(3)  +     3; break;
  748.     case 12:   t_ptr->p1 = randint(8)  +     6; break;
  749.     case 13:   t_ptr->p1 = randint(10) +     6; break;
  750.     case 14:   t_ptr->p1 = randint(5)  +     3; break;
  751.     case 15:   t_ptr->p1 = randint(5)  +     3; break;
  752.     case 16:   t_ptr->p1 = randint(5)  +     6; break;
  753.     case 17:   t_ptr->p1 = randint(5)  +     4; break;
  754.     case 18:   t_ptr->p1 = randint(8)  +     4; break;
  755.     case 19:   t_ptr->p1 = randint(6)  +     2; break;
  756.     case 20:   t_ptr->p1 = randint(4)  +     2; break;
  757.     case 21:   t_ptr->p1 = randint(8)  +     6; break;
  758.     case 22:   t_ptr->p1 = randint(5)  +     2; break;
  759.     case 23:   t_ptr->p1 = randint(12) + 12; break;
  760.     default:
  761.       break;
  762.     }
  763.       break;
  764.  
  765.     case TV_STAFF:
  766.       switch(t_ptr->subval)
  767.     {
  768.     case 0:      t_ptr->p1 = randint(20) +     12; break;
  769.     case 1:      t_ptr->p1 = randint(8)  +     6; break;
  770.     case 2:      t_ptr->p1 = randint(5)  +     6; break;
  771.     case 3:      t_ptr->p1 = randint(20) +     12; break;
  772.     case 4:      t_ptr->p1 = randint(15) +     6; break;
  773.     case 5:      t_ptr->p1 = randint(4)  +     5; break;
  774.     case 6:      t_ptr->p1 = randint(5)  +     3; break;
  775.     case 7:      t_ptr->p1 = randint(3)  +     1;
  776.       t_ptr->level = 10;
  777.       break;
  778.     case 8:      t_ptr->p1 = randint(3)  +     1; break;
  779.     case 9:      t_ptr->p1 = randint(5)  +     6; break;
  780.     case 10:   t_ptr->p1 = randint(10) +     12; break;
  781.     case 11:   t_ptr->p1 = randint(5)  +     6; break;
  782.     case 12:   t_ptr->p1 = randint(5)  +     6; break;
  783.     case 13:   t_ptr->p1 = randint(5)  +     6; break;
  784.     case 14:   t_ptr->p1 = randint(10) +     12; break;
  785.     case 15:   t_ptr->p1 = randint(3)  +     4; break;
  786.     case 16:   t_ptr->p1 = randint(5)  +     6; break;
  787.     case 17:   t_ptr->p1 = randint(5)  +     6; break;
  788.     case 18:   t_ptr->p1 = randint(3)  +     4; break;
  789.     case 19:   t_ptr->p1 = randint(10) +     12; break;
  790.     case 20:   t_ptr->p1 = randint(3)  +     4; break;
  791.     case 21:   t_ptr->p1 = randint(3)  +     4; break;
  792.     case 22:   t_ptr->p1 = randint(10) + 6;
  793.       t_ptr->level = 5;
  794.       break;
  795.     default:
  796.       break;
  797.     }
  798.       break;
  799.  
  800.     case TV_CLOAK:
  801.       if (magik(chance))
  802.     {
  803.       if (magik(special))
  804.         {
  805.           if (randint(2) == 1)
  806.         {
  807.           t_ptr->name2 = SN_PROTECTION;
  808.           t_ptr->toac += m_bonus(2, 40, level);
  809.           t_ptr->cost += 250;
  810.         }
  811.           else
  812.         {
  813.           t_ptr->toac += m_bonus(1, 20, level);
  814.           t_ptr->ident |= ID_SHOW_P1;
  815.           t_ptr->p1 = randint(3);
  816.           t_ptr->flags |= TR_STEALTH;
  817.           t_ptr->name2 = SN_STEALTH;
  818.           t_ptr->cost += 500;
  819.         }
  820.         }
  821.       else
  822.         t_ptr->toac += m_bonus(1, 20, level);
  823.     }
  824.       else if (magik(cursed))
  825.     {
  826.       tmp = randint(3);
  827.       if (tmp == 1)
  828.         {
  829.           t_ptr->flags |= TR_AGGRAVATE;
  830.           t_ptr->name2 = SN_IRRITATION;
  831.           t_ptr->toac  -= m_bonus(1, 10, level);
  832.           t_ptr->ident |= ID_SHOW_HITDAM;
  833.           t_ptr->tohit -= m_bonus(1, 10, level);
  834.           t_ptr->todam -= m_bonus(1, 10, level);
  835.           t_ptr->cost =  0;
  836.         }
  837.       else if (tmp == 2)
  838.         {
  839.           t_ptr->name2 = SN_VULNERABILITY;
  840.           t_ptr->toac -= m_bonus(10, 100, level+50);
  841.           t_ptr->cost = 0;
  842.         }
  843.       else
  844.         {
  845.           t_ptr->name2 = SN_ENVELOPING;
  846.           t_ptr->toac  -= m_bonus(1, 10, level);
  847.           t_ptr->ident |= ID_SHOW_HITDAM;
  848.           t_ptr->tohit -= m_bonus(2, 40, level+10);
  849.           t_ptr->todam -= m_bonus(2, 40, level+10);
  850.           t_ptr->cost = 0;
  851.         }
  852. #ifdef ATARIST_MWC
  853.       t_ptr->flags |= (holder = TR_CURSED);
  854. #else
  855.       t_ptr->flags |= TR_CURSED;
  856. #endif
  857.     }
  858.       break;
  859.  
  860.     case TV_CHEST:
  861.       switch(randint(level+4))
  862.     {
  863.     case 1:
  864.       t_ptr->flags = 0;
  865.       t_ptr->name2 = SN_EMPTY;
  866.       break;
  867.     case 2:
  868.       t_ptr->flags |= CH_LOCKED;
  869.       t_ptr->name2 = SN_LOCKED;
  870.       break;
  871.     case 3: case 4:
  872.       t_ptr->flags |= (CH_LOSE_STR|CH_LOCKED);
  873.       t_ptr->name2 = SN_POISON_NEEDLE;
  874.       break;
  875.     case 5: case 6:
  876.       t_ptr->flags |= (CH_POISON|CH_LOCKED);
  877.       t_ptr->name2 = SN_POISON_NEEDLE;
  878.       break;
  879.     case 7: case 8: case 9:
  880.       t_ptr->flags |= (CH_PARALYSED|CH_LOCKED);
  881.       t_ptr->name2 = SN_GAS_TRAP;
  882.       break;
  883.     case 10: case 11:
  884.       t_ptr->flags |= (CH_EXPLODE|CH_LOCKED);
  885.       t_ptr->name2 = SN_EXPLOSION_DEVICE;
  886.       break;
  887.     case 12: case 13: case 14:
  888.       t_ptr->flags |= (CH_SUMMON|CH_LOCKED);
  889.       t_ptr->name2 = SN_SUMMONING_RUNES;
  890.       break;
  891.     case 15: case 16: case 17:
  892.       t_ptr->flags |= (CH_PARALYSED|CH_POISON|CH_LOSE_STR|CH_LOCKED);
  893.       t_ptr->name2 = SN_MULTIPLE_TRAPS;
  894.       break;
  895.     default:
  896.       t_ptr->flags |= (CH_SUMMON|CH_EXPLODE|CH_LOCKED);
  897.       t_ptr->name2 = SN_MULTIPLE_TRAPS;
  898.       break;
  899.     }
  900.       break;
  901.  
  902.     case TV_SLING_AMMO: case TV_SPIKE:
  903.     case TV_BOLT: case TV_ARROW:
  904.       if (t_ptr->tval == TV_SLING_AMMO || t_ptr->tval == TV_BOLT
  905.       || t_ptr->tval == TV_ARROW)
  906.     {
  907.       /* always show tohit/todam values if identified */
  908.       t_ptr->ident |= ID_SHOW_HITDAM;
  909.  
  910.       if (magik(chance))
  911.         {
  912.           t_ptr->tohit += m_bonus(1, 35, level);
  913.           t_ptr->todam += m_bonus(1, 35, level);
  914.           /* see comment for weapons */
  915.           if (magik(3*special/2))
  916.         switch(randint(10))
  917.           {
  918.           case 1: case 2: case 3:
  919.             t_ptr->name2 = SN_SLAYING;
  920.             t_ptr->tohit += 5;
  921.             t_ptr->todam += 5;
  922.             t_ptr->cost += 20;
  923.             break;
  924.           case 4: case 5:
  925. #ifdef ATARIST_MWC
  926.             t_ptr->flags |= (holder = TR_FLAME_TONGUE);
  927. #else
  928.             t_ptr->flags |= TR_FLAME_TONGUE;
  929. #endif
  930.             t_ptr->tohit += 2;
  931.             t_ptr->todam += 4;
  932.             t_ptr->name2 = SN_FIRE;
  933.             t_ptr->cost += 25;
  934.             break;
  935.           case 6: case 7:
  936.             t_ptr->flags |= TR_SLAY_EVIL;
  937.             t_ptr->tohit += 3;
  938.             t_ptr->todam += 3;
  939.             t_ptr->name2 = SN_SLAY_EVIL;
  940.             t_ptr->cost += 25;
  941.             break;
  942.           case 8: case 9:
  943.             t_ptr->flags |= TR_SLAY_ANIMAL;
  944.             t_ptr->tohit += 2;
  945.             t_ptr->todam += 2;
  946.             t_ptr->name2 = SN_SLAY_ANIMAL;
  947.             t_ptr->cost += 30;
  948.             break;
  949.           case 10:
  950.             t_ptr->flags |= TR_SLAY_DRAGON;
  951.             t_ptr->tohit += 3;
  952.             t_ptr->todam += 3;
  953.             t_ptr->name2 = SN_DRAGON_SLAYING;
  954.             t_ptr->cost += 35;
  955.             break;
  956.           }
  957.         }
  958.       else if (magik(cursed))
  959.         {
  960.           t_ptr->tohit -= m_bonus(5, 55, level);
  961.           t_ptr->todam -= m_bonus(5, 55, level);
  962. #ifdef ATARIST_MWC
  963.           t_ptr->flags |= (holder = TR_CURSED);
  964. #else
  965.           t_ptr->flags |= TR_CURSED;
  966. #endif
  967.           t_ptr->cost = 0;
  968.         }
  969.     }
  970.  
  971.       t_ptr->number = 0;
  972.       for (i = 0; i < 7; i++)
  973.     t_ptr->number += randint(6);
  974.       if (missile_ctr == MAX_SHORT)
  975.     missile_ctr = -MAX_SHORT - 1;
  976.       else
  977.     missile_ctr++;
  978.       t_ptr->p1 = missile_ctr;
  979.       break;
  980.  
  981.     case TV_FOOD:
  982.       /* make sure all food rations have the same level */
  983.       if (t_ptr->subval == 90)
  984.     t_ptr->level = 0;
  985.       /* give all elvish waybread the same level */
  986.       else if (t_ptr->subval == 92)
  987.     t_ptr->level = 6;
  988.       break;
  989.  
  990.     case TV_SCROLL1:
  991.       /* give all identify scrolls the same level */
  992.       if (t_ptr->subval == 67)
  993.     t_ptr->level = 1;
  994.       /* scroll of light */
  995.       else if (t_ptr->subval == 69)
  996.     t_ptr->level = 0;
  997.       /* scroll of trap detection */
  998.       else if (t_ptr->subval == 80)
  999.     t_ptr->level = 5;
  1000.       /* scroll of door/stair location */
  1001.       else if (t_ptr->subval == 81)
  1002.     t_ptr->level = 5;
  1003.       break;
  1004.  
  1005.     case TV_POTION1:  /* potions */
  1006.       /* cure light */
  1007.       if (t_ptr->subval == 76)
  1008.     t_ptr->level = 0;
  1009.       break;
  1010.  
  1011.     default:
  1012.       break;
  1013.     }
  1014. }
  1015.  
  1016.  
  1017. static struct opt_desc { char *o_prompt; int *o_var; } options[] = {
  1018.   { "Running: cut known corners",        &find_cut },
  1019.   { "Running: examine potential corners",    &find_examine },
  1020.   { "Running: print self during run",        &find_prself },
  1021.   { "Running: stop when map sector changes",    &find_bound },
  1022.   { "Running: run through open doors",        &find_ignore_doors },
  1023.   { "Prompt to pick up objects",        &prompt_carry_flag },
  1024.   { "Rogue like commands",            &rogue_like_commands },
  1025.   { "Show weights in inventory",        &show_weight_flag },
  1026.   { "Highlight and notice mineral seams",    &highlight_seams },
  1027.   { "Beep for invalid character",        &sound_beep_flag },
  1028.   { "Display rest/repeat counts",        &display_counts },
  1029.   { 0, 0 } };
  1030.  
  1031.  
  1032. /* Set or unset various boolean options.        -CJS- */
  1033. void set_options()
  1034. {
  1035.   register int i, max;
  1036.   vtype string;
  1037.  
  1038.   prt("  ESC when finished, y/n to set options, <return> or - to move cursor",
  1039.         0, 0);
  1040.   for (max = 0; options[max].o_prompt != 0; max++)
  1041.     {
  1042.       (void) sprintf(string, "%-38s: %s", options[max].o_prompt,
  1043.              (*options[max].o_var ? "yes" : "no "));
  1044.       prt(string, max+1, 0);
  1045.     }
  1046.   erase_line(max+1, 0);
  1047.   i = 0;
  1048.   for(;;)
  1049.     {
  1050.       move_cursor(i+1, 40);
  1051.       switch(inkey())
  1052.     {
  1053.     case ESCAPE:
  1054.       return;
  1055.     case '-':
  1056.       if (i > 0)
  1057.         i--;
  1058.       else
  1059.         i = max-1;
  1060.       break;
  1061.     case ' ':
  1062.     case '\n':
  1063.     case '\r':
  1064.       if (i+1 < max)
  1065.         i++;
  1066.       else
  1067.         i = 0;
  1068.       break;
  1069.     case 'y':
  1070.     case 'Y':
  1071.       put_buffer("yes", i+1, 40);
  1072.       *options[i].o_var = TRUE;
  1073.       if (i+1 < max)
  1074.         i++;
  1075.       else
  1076.         i = 0;
  1077.       break;
  1078.     case 'n':
  1079.     case 'N':
  1080.       put_buffer("no ", i+1, 40);
  1081.       *options[i].o_var = FALSE;
  1082.       if (i+1 < max)
  1083.         i++;
  1084.       else
  1085.         i = 0;
  1086.       break;
  1087.     default:
  1088.       bell();
  1089.       break;
  1090.     }
  1091.     }
  1092. }
  1093.